home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / misc / FloatingDecimal.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  15.2 KB  |  1,350 lines
  1. package sun.misc;
  2.  
  3. import java.util.regex.Matcher;
  4. import java.util.regex.Pattern;
  5.  
  6. public class FloatingDecimal {
  7.    boolean isExceptional;
  8.    boolean isNegative;
  9.    int decExponent;
  10.    char[] digits;
  11.    int nDigits;
  12.    int bigIntExp;
  13.    int bigIntNBits;
  14.    boolean mustSetRoundDir = false;
  15.    boolean fromHex = false;
  16.    int roundDir = 0;
  17.    static final long signMask = Long.MIN_VALUE;
  18.    static final long expMask = 9218868437227405312L;
  19.    static final long fractMask = 4503599627370495L;
  20.    static final int expShift = 52;
  21.    static final int expBias = 1023;
  22.    static final long fractHOB = 4503599627370496L;
  23.    static final long expOne = 4607182418800017408L;
  24.    static final int maxSmallBinExp = 62;
  25.    static final int minSmallBinExp = -21;
  26.    static final int maxDecimalDigits = 15;
  27.    static final int maxDecimalExponent = 308;
  28.    static final int minDecimalExponent = -324;
  29.    static final int bigDecimalExponent = 324;
  30.    static final long highbyte = -72057594037927936L;
  31.    static final long highbit = Long.MIN_VALUE;
  32.    static final long lowbytes = 72057594037927935L;
  33.    static final int singleSignMask = Integer.MIN_VALUE;
  34.    static final int singleExpMask = 2139095040;
  35.    static final int singleFractMask = 8388607;
  36.    static final int singleExpShift = 23;
  37.    static final int singleFractHOB = 8388608;
  38.    static final int singleExpBias = 127;
  39.    static final int singleMaxDecimalDigits = 7;
  40.    static final int singleMaxDecimalExponent = 38;
  41.    static final int singleMinDecimalExponent = -45;
  42.    static final int intDecimalDigits = 9;
  43.    private static FDBigInt[] b5p;
  44.    private static ThreadLocal perThreadBuffer = new 1();
  45.    private static final double[] small10pow = new double[]{(double)1.0F, (double)10.0F, (double)100.0F, (double)1000.0F, (double)10000.0F, (double)100000.0F, (double)1000000.0F, (double)1.0E7F, (double)1.0E8F, (double)1.0E9F, (double)1.0E10F, 1.0E11, 1.0E12, 1.0E13, 1.0E14, 1.0E15, 1.0E16, 1.0E17, 1.0E18, 1.0E19, 1.0E20, 1.0E21, 1.0E22};
  46.    private static final float[] singleSmall10pow = new float[]{1.0F, 10.0F, 100.0F, 1000.0F, 10000.0F, 100000.0F, 1000000.0F, 1.0E7F, 1.0E8F, 1.0E9F, 1.0E10F};
  47.    private static final double[] big10pow = new double[]{1.0E16, 1.0E32, 1.0E64, 1.0E128, 1.0E256};
  48.    private static final double[] tiny10pow = new double[]{1.0E-16, 1.0E-32, 1.0E-64, 1.0E-128, 1.0E-256};
  49.    private static final int maxSmallTen;
  50.    private static final int singleMaxSmallTen;
  51.    private static final int[] small5pow;
  52.    private static final long[] long5pow;
  53.    private static final int[] n5bits;
  54.    private static final char[] infinity;
  55.    private static final char[] notANumber;
  56.    private static final char[] zero;
  57.    private static Pattern hexFloatPattern;
  58.  
  59.    private FloatingDecimal(boolean var1, int var2, char[] var3, int var4, boolean var5) {
  60.       this.isNegative = var1;
  61.       this.isExceptional = var5;
  62.       this.decExponent = var2;
  63.       this.digits = var3;
  64.       this.nDigits = var4;
  65.    }
  66.  
  67.    private static int countBits(long var0) {
  68.       if (var0 == 0L) {
  69.          return 0;
  70.       } else {
  71.          while((var0 & -72057594037927936L) == 0L) {
  72.             var0 <<= 8;
  73.          }
  74.  
  75.          while(var0 > 0L) {
  76.             var0 <<= 1;
  77.          }
  78.  
  79.          int var2;
  80.          for(var2 = 0; (var0 & 72057594037927935L) != 0L; var2 += 8) {
  81.             var0 <<= 8;
  82.          }
  83.  
  84.          while(var0 != 0L) {
  85.             var0 <<= 1;
  86.             ++var2;
  87.          }
  88.  
  89.          return var2;
  90.       }
  91.    }
  92.  
  93.    private static synchronized FDBigInt big5pow(int var0) {
  94.       assert var0 >= 0 : var0;
  95.  
  96.       if (b5p == null) {
  97.          b5p = new FDBigInt[var0 + 1];
  98.       } else if (b5p.length <= var0) {
  99.          FDBigInt[] var1 = new FDBigInt[var0 + 1];
  100.          System.arraycopy(b5p, 0, var1, 0, b5p.length);
  101.          b5p = var1;
  102.       }
  103.  
  104.       if (b5p[var0] != null) {
  105.          return b5p[var0];
  106.       } else if (var0 < small5pow.length) {
  107.          return b5p[var0] = new FDBigInt(small5pow[var0]);
  108.       } else if (var0 < long5pow.length) {
  109.          return b5p[var0] = new FDBigInt(long5pow[var0]);
  110.       } else {
  111.          int var5 = var0 >> 1;
  112.          int var2 = var0 - var5;
  113.          FDBigInt var3 = b5p[var5];
  114.          if (var3 == null) {
  115.             var3 = big5pow(var5);
  116.          }
  117.  
  118.          if (var2 < small5pow.length) {
  119.             return b5p[var0] = var3.mult(small5pow[var2]);
  120.          } else {
  121.             FDBigInt var4 = b5p[var2];
  122.             if (var4 == null) {
  123.                var4 = big5pow(var2);
  124.             }
  125.  
  126.             return b5p[var0] = var3.mult(var4);
  127.          }
  128.       }
  129.    }
  130.  
  131.    private static FDBigInt multPow52(FDBigInt var0, int var1, int var2) {
  132.       if (var1 != 0) {
  133.          if (var1 < small5pow.length) {
  134.             var0 = var0.mult(small5pow[var1]);
  135.          } else {
  136.             var0 = var0.mult(big5pow(var1));
  137.          }
  138.       }
  139.  
  140.       if (var2 != 0) {
  141.          var0.lshiftMe(var2);
  142.       }
  143.  
  144.       return var0;
  145.    }
  146.  
  147.    private static FDBigInt constructPow52(int var0, int var1) {
  148.       FDBigInt var2 = new FDBigInt(big5pow(var0));
  149.       if (var1 != 0) {
  150.          var2.lshiftMe(var1);
  151.       }
  152.  
  153.       return var2;
  154.    }
  155.  
  156.    private FDBigInt doubleToBigInt(double var1) {
  157.       // $FF: Couldn't be decompiled
  158.    }
  159.  
  160.    private static double ulp(double var0, boolean var2) {
  161.       long var3 = Double.doubleToLongBits(var0) & Long.MAX_VALUE;
  162.       int var5 = (int)(var3 >>> 52);
  163.       if (var2 && var5 >= 52 && (var3 & 4503599627370495L) == 0L) {
  164.          --var5;
  165.       }
  166.  
  167.       double var6;
  168.       if (var5 > 52) {
  169.          var6 = Double.longBitsToDouble((long)(var5 - 52) << 52);
  170.       } else if (var5 == 0) {
  171.          var6 = Double.MIN_VALUE;
  172.       } else {
  173.          var6 = Double.longBitsToDouble(1L << var5 - 1);
  174.       }
  175.  
  176.       if (var2) {
  177.          var6 = -var6;
  178.       }
  179.  
  180.       return var6;
  181.    }
  182.  
  183.    float stickyRound(double var1) {
  184.       long var3 = Double.doubleToLongBits(var1);
  185.       long var5 = var3 & 9218868437227405312L;
  186.       if (var5 != 0L && var5 != 9218868437227405312L) {
  187.          var3 += (long)this.roundDir;
  188.          return (float)Double.longBitsToDouble(var3);
  189.       } else {
  190.          return (float)var1;
  191.       }
  192.    }
  193.  
  194.    private void developLongDigits(int var1, long var2, long var4) {
  195.       int var10;
  196.       for(var10 = 0; var4 >= 10L; ++var10) {
  197.          var4 /= 10L;
  198.       }
  199.  
  200.       if (var10 != 0) {
  201.          long var11 = long5pow[var10] << var10;
  202.          long var13 = var2 % var11;
  203.          var2 /= var11;
  204.          var1 += var10;
  205.          if (var13 >= var11 >> 1) {
  206.             ++var2;
  207.          }
  208.       }
  209.  
  210.       char[] var6;
  211.       byte var7;
  212.       int var8;
  213.       if (var2 <= 2147483647L) {
  214.          assert var2 > 0L : var2;
  215.  
  216.          int var18 = (int)var2;
  217.          var7 = 10;
  218.          var6 = (char[])perThreadBuffer.get();
  219.          var8 = var7 - 1;
  220.          int var9 = var18 % 10;
  221.  
  222.          for(var18 /= 10; var9 == 0; var18 /= 10) {
  223.             ++var1;
  224.             var9 = var18 % 10;
  225.          }
  226.  
  227.          while(var18 != 0) {
  228.             var6[var8--] = (char)(var9 + 48);
  229.             ++var1;
  230.             var9 = var18 % 10;
  231.             var18 /= 10;
  232.          }
  233.  
  234.          var6[var8] = (char)(var9 + 48);
  235.       } else {
  236.          var7 = 20;
  237.          var6 = (char[])perThreadBuffer.get();
  238.          var8 = var7 - 1;
  239.          int var17 = (int)(var2 % 10L);
  240.  
  241.          for(var2 /= 10L; var17 == 0; var2 /= 10L) {
  242.             ++var1;
  243.             var17 = (int)(var2 % 10L);
  244.          }
  245.  
  246.          while(var2 != 0L) {
  247.             var6[var8--] = (char)(var17 + 48);
  248.             ++var1;
  249.             var17 = (int)(var2 % 10L);
  250.             var2 /= 10L;
  251.          }
  252.  
  253.          var6[var8] = (char)(var17 + 48);
  254.       }
  255.  
  256.       var7 -= var8;
  257.       char[] var20 = new char[var7];
  258.       System.arraycopy(var6, var8, var20, 0, var7);
  259.       this.digits = var20;
  260.       this.decExponent = var1 + 1;
  261.       this.nDigits = var7;
  262.    }
  263.  
  264.    private void roundup() {
  265.       int var1;
  266.       char var2 = this.digits[var1 = this.nDigits - 1];
  267.       if (var2 == '9') {
  268.          while(var2 == '9' && var1 > 0) {
  269.             this.digits[var1] = '0';
  270.             --var1;
  271.             var2 = this.digits[var1];
  272.          }
  273.  
  274.          if (var2 == '9') {
  275.             ++this.decExponent;
  276.             this.digits[0] = '1';
  277.             return;
  278.          }
  279.       }
  280.  
  281.       this.digits[var1] = (char)(var2 + 1);
  282.    }
  283.  
  284.    public FloatingDecimal(double var1) {
  285.       long var3 = Double.doubleToLongBits(var1);
  286.       if ((var3 & Long.MIN_VALUE) != 0L) {
  287.          this.isNegative = true;
  288.          var3 ^= Long.MIN_VALUE;
  289.       } else {
  290.          this.isNegative = false;
  291.       }
  292.  
  293.       int var7 = (int)((var3 & 9218868437227405312L) >> 52);
  294.       long var5 = var3 & 4503599627370495L;
  295.       if (var7 == 2047) {
  296.          this.isExceptional = true;
  297.          if (var5 == 0L) {
  298.             this.digits = infinity;
  299.          } else {
  300.             this.digits = notANumber;
  301.             this.isNegative = false;
  302.          }
  303.  
  304.          this.nDigits = this.digits.length;
  305.       } else {
  306.          this.isExceptional = false;
  307.          int var8;
  308.          if (var7 == 0) {
  309.             if (var5 == 0L) {
  310.                this.decExponent = 0;
  311.                this.digits = zero;
  312.                this.nDigits = 1;
  313.                return;
  314.             }
  315.  
  316.             while((var5 & 4503599627370496L) == 0L) {
  317.                var5 <<= 1;
  318.                --var7;
  319.             }
  320.  
  321.             var8 = 52 + var7 + 1;
  322.             ++var7;
  323.          } else {
  324.             var5 |= 4503599627370496L;
  325.             var8 = 53;
  326.          }
  327.  
  328.          var7 -= 1023;
  329.          this.dtoa(var7, var5, var8);
  330.       }
  331.    }
  332.  
  333.    public FloatingDecimal(float var1) {
  334.       int var2 = Float.floatToIntBits(var1);
  335.       if ((var2 & Integer.MIN_VALUE) != 0) {
  336.          this.isNegative = true;
  337.          var2 ^= Integer.MIN_VALUE;
  338.       } else {
  339.          this.isNegative = false;
  340.       }
  341.  
  342.       int var4 = (var2 & 2139095040) >> 23;
  343.       int var3 = var2 & 8388607;
  344.       if (var4 == 255) {
  345.          this.isExceptional = true;
  346.          if ((long)var3 == 0L) {
  347.             this.digits = infinity;
  348.          } else {
  349.             this.digits = notANumber;
  350.             this.isNegative = false;
  351.          }
  352.  
  353.          this.nDigits = this.digits.length;
  354.       } else {
  355.          this.isExceptional = false;
  356.          int var5;
  357.          if (var4 == 0) {
  358.             if (var3 == 0) {
  359.                this.decExponent = 0;
  360.                this.digits = zero;
  361.                this.nDigits = 1;
  362.                return;
  363.             }
  364.  
  365.             while((var3 & 8388608) == 0) {
  366.                var3 <<= 1;
  367.                --var4;
  368.             }
  369.  
  370.             var5 = 23 + var4 + 1;
  371.             ++var4;
  372.          } else {
  373.             var3 |= 8388608;
  374.             var5 = 24;
  375.          }
  376.  
  377.          var4 -= 127;
  378.          this.dtoa(var4, (long)var3 << 29, var5);
  379.       }
  380.    }
  381.  
  382.    private void dtoa(int var1, long var2, int var4) {
  383.       int var5 = countBits(var2);
  384.       int var6 = Math.max(0, var5 - var1 - 1);
  385.       if (var1 <= 62 && var1 >= -21 && var6 < long5pow.length && var5 + n5bits[var6] < 64 && var6 == 0) {
  386.          long var39;
  387.          if (var1 > var4) {
  388.             var39 = 1L << var1 - var4 - 1;
  389.          } else {
  390.             var39 = 0L;
  391.          }
  392.  
  393.          if (var1 >= 52) {
  394.             var2 <<= var1 - 52;
  395.          } else {
  396.             var2 >>>= 52 - var1;
  397.          }
  398.  
  399.          this.developLongDigits(0, var2, var39);
  400.       } else {
  401.          double var8 = Double.longBitsToDouble(4607182418800017408L | var2 & -4503599627370497L);
  402.          int var7 = (int)Math.floor((var8 - (double)1.5F) * 0.289529654 + 0.176091259 + (double)var1 * 0.301029995663981);
  403.          int var11 = Math.max(0, -var7);
  404.          int var10 = var11 + var6 + var1;
  405.          int var13 = Math.max(0, var7);
  406.          int var12 = var13 + var6;
  407.          int var14 = var10 - var4;
  408.          var2 >>>= 53 - var5;
  409.          var10 -= var5 - 1;
  410.          int var21 = Math.min(var10, var12);
  411.          var10 -= var21;
  412.          var12 -= var21;
  413.          var14 -= var21;
  414.          if (var5 == 1) {
  415.             --var14;
  416.          }
  417.  
  418.          if (var14 < 0) {
  419.             var10 -= var14;
  420.             var12 -= var14;
  421.             var14 = 0;
  422.          }
  423.  
  424.          char[] var22 = this.digits = new char[18];
  425.          int var23 = 0;
  426.          int var16 = var5 + var10 + (var11 < n5bits.length ? n5bits[var11] : var11 * 3);
  427.          int var17 = var12 + 1 + (var13 + 1 < n5bits.length ? n5bits[var13 + 1] : (var13 + 1) * 3);
  428.          boolean var24;
  429.          boolean var25;
  430.          long var26;
  431.          if (var16 < 64 && var17 < 64) {
  432.             if (var16 < 32 && var17 < 32) {
  433.                int var53 = (int)var2 * small5pow[var11] << var10;
  434.                int var55 = small5pow[var13] << var12;
  435.                int var56 = small5pow[var11] << var14;
  436.                int var32 = var55 * 10;
  437.                var23 = 0;
  438.                int var49 = var53 / var55;
  439.                var53 = 10 * (var53 % var55);
  440.                var56 *= 10;
  441.                var24 = var53 < var56;
  442.                var25 = var53 + var56 > var32;
  443.  
  444.                assert var49 < 10 : var49;
  445.  
  446.                if (var49 == 0 && !var25) {
  447.                   --var7;
  448.                } else {
  449.                   var22[var23++] = (char)(48 + var49);
  450.                }
  451.  
  452.                if (var7 <= -3 || var7 >= 8) {
  453.                   var24 = false;
  454.                   var25 = false;
  455.                }
  456.  
  457.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var49)) {
  458.                   var49 = var53 / var55;
  459.                   var53 = 10 * (var53 % var55);
  460.                   var56 *= 10;
  461.  
  462.                   assert var49 < 10 : var49;
  463.  
  464.                   if ((long)var56 > 0L) {
  465.                      var24 = var53 < var56;
  466.                      var25 = var53 + var56 > var32;
  467.                   } else {
  468.                      var24 = true;
  469.                      var25 = true;
  470.                   }
  471.                }
  472.  
  473.                var26 = (long)((var53 << 1) - var32);
  474.             } else {
  475.                long var51 = var2 * long5pow[var11] << var10;
  476.                long var31 = long5pow[var13] << var12;
  477.                long var33 = long5pow[var11] << var14;
  478.                long var35 = var31 * 10L;
  479.                var23 = 0;
  480.                int var47 = (int)(var51 / var31);
  481.                var51 = 10L * (var51 % var31);
  482.                var33 *= 10L;
  483.                var24 = var51 < var33;
  484.                var25 = var51 + var33 > var35;
  485.  
  486.                assert var47 < 10 : var47;
  487.  
  488.                if (var47 == 0 && !var25) {
  489.                   --var7;
  490.                } else {
  491.                   var22[var23++] = (char)(48 + var47);
  492.                }
  493.  
  494.                if (var7 <= -3 || var7 >= 8) {
  495.                   var24 = false;
  496.                   var25 = false;
  497.                }
  498.  
  499.                for(; !var24 && !var25; var22[var23++] = (char)(48 + var47)) {
  500.                   var47 = (int)(var51 / var31);
  501.                   var51 = 10L * (var51 % var31);
  502.                   var33 *= 10L;
  503.  
  504.                   assert var47 < 10 : var47;
  505.  
  506.                   if (var33 > 0L) {
  507.                      var24 = var51 < var33;
  508.                      var25 = var51 + var33 > var35;
  509.                   } else {
  510.                      var24 = true;
  511.                      var25 = true;
  512.                   }
  513.                }
  514.  
  515.                var26 = (var51 << 1) - var35;
  516.             }
  517.          } else {
  518.             FDBigInt var19 = multPow52(new FDBigInt(var2), var11, var10);
  519.             FDBigInt var18 = constructPow52(var13, var12);
  520.             FDBigInt var20 = constructPow52(var11, var14);
  521.             int var30;
  522.             var19.lshiftMe(var30 = var18.normalizeMe());
  523.             var20.lshiftMe(var30);
  524.             FDBigInt var29 = var18.mult(10);
  525.             var23 = 0;
  526.             int var28 = var19.quoRemIteration(var18);
  527.             var20 = var20.mult(10);
  528.             var24 = var19.cmp(var20) < 0;
  529.             var25 = var19.add(var20).cmp(var29) > 0;
  530.  
  531.             assert var28 < 10 : var28;
  532.  
  533.             if (var28 == 0 && !var25) {
  534.                --var7;
  535.             } else {
  536.                var22[var23++] = (char)(48 + var28);
  537.             }
  538.  
  539.             if (var7 <= -3 || var7 >= 8) {
  540.                var24 = false;
  541.                var25 = false;
  542.             }
  543.  
  544.             while(!var24 && !var25) {
  545.                var28 = var19.quoRemIteration(var18);
  546.                var20 = var20.mult(10);
  547.  
  548.                assert var28 < 10 : var28;
  549.  
  550.                var24 = var19.cmp(var20) < 0;
  551.                var25 = var19.add(var20).cmp(var29) > 0;
  552.                var22[var23++] = (char)(48 + var28);
  553.             }
  554.  
  555.             if (var25 && var24) {
  556.                var19.lshiftMe(1);
  557.                var26 = (long)var19.cmp(var29);
  558.             } else {
  559.                var26 = 0L;
  560.             }
  561.          }
  562.  
  563.          this.decExponent = var7 + 1;
  564.          this.digits = var22;
  565.          this.nDigits = var23;
  566.          if (var25) {
  567.             if (var24) {
  568.                if (var26 == 0L) {
  569.                   if ((var22[this.nDigits - 1] & 1) != 0) {
  570.                      this.roundup();
  571.                   }
  572.                } else if (var26 > 0L) {
  573.                   this.roundup();
  574.                }
  575.             } else {
  576.                this.roundup();
  577.             }
  578.          }
  579.  
  580.       }
  581.    }
  582.  
  583.    public String toString() {
  584.       StringBuffer var1 = new StringBuffer(this.nDigits + 8);
  585.       if (this.isNegative) {
  586.          var1.append('-');
  587.       }
  588.  
  589.       if (this.isExceptional) {
  590.          var1.append(this.digits, 0, this.nDigits);
  591.       } else {
  592.          var1.append("0.");
  593.          var1.append(this.digits, 0, this.nDigits);
  594.          var1.append('e');
  595.          var1.append(this.decExponent);
  596.       }
  597.  
  598.       return new String(var1);
  599.    }
  600.  
  601.    public String toJavaFormatString() {
  602.       char[] var1 = (char[])perThreadBuffer.get();
  603.       int var2 = this.getChars(var1);
  604.       return new String(var1, 0, var2);
  605.    }
  606.  
  607.    private int getChars(char[] var1) {
  608.       assert this.nDigits <= 19 : this.nDigits;
  609.  
  610.       int var2 = 0;
  611.       if (this.isNegative) {
  612.          var1[0] = '-';
  613.          var2 = 1;
  614.       }
  615.  
  616.       if (this.isExceptional) {
  617.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  618.          var2 += this.nDigits;
  619.       } else if (this.decExponent > 0 && this.decExponent < 8) {
  620.          int var20 = Math.min(this.nDigits, this.decExponent);
  621.          System.arraycopy(this.digits, 0, var1, var2, var20);
  622.          var2 += var20;
  623.          if (var20 < this.decExponent) {
  624.             var20 = this.decExponent - var20;
  625.             System.arraycopy(zero, 0, var1, var2, var20);
  626.             var2 += var20;
  627.             var1[var2++] = '.';
  628.             var1[var2++] = '0';
  629.          } else {
  630.             var1[var2++] = '.';
  631.             if (var20 < this.nDigits) {
  632.                int var4 = this.nDigits - var20;
  633.                System.arraycopy(this.digits, var20, var1, var2, var4);
  634.                var2 += var4;
  635.             } else {
  636.                var1[var2++] = '0';
  637.             }
  638.          }
  639.       } else if (this.decExponent <= 0 && this.decExponent > -3) {
  640.          var1[var2++] = '0';
  641.          var1[var2++] = '.';
  642.          if (this.decExponent != 0) {
  643.             System.arraycopy(zero, 0, var1, var2, -this.decExponent);
  644.             var2 -= this.decExponent;
  645.          }
  646.  
  647.          System.arraycopy(this.digits, 0, var1, var2, this.nDigits);
  648.          var2 += this.nDigits;
  649.       } else {
  650.          var1[var2++] = this.digits[0];
  651.          var1[var2++] = '.';
  652.          if (this.nDigits > 1) {
  653.             System.arraycopy(this.digits, 1, var1, var2, this.nDigits - 1);
  654.             var2 += this.nDigits - 1;
  655.          } else {
  656.             var1[var2++] = '0';
  657.          }
  658.  
  659.          var1[var2++] = 'E';
  660.          int var3;
  661.          if (this.decExponent <= 0) {
  662.             var1[var2++] = '-';
  663.             var3 = -this.decExponent + 1;
  664.          } else {
  665.             var3 = this.decExponent - 1;
  666.          }
  667.  
  668.          if (var3 <= 9) {
  669.             var1[var2++] = (char)(var3 + 48);
  670.          } else if (var3 <= 99) {
  671.             var1[var2++] = (char)(var3 / 10 + 48);
  672.             var1[var2++] = (char)(var3 % 10 + 48);
  673.          } else {
  674.             var1[var2++] = (char)(var3 / 100 + 48);
  675.             var3 %= 100;
  676.             var1[var2++] = (char)(var3 / 10 + 48);
  677.             var1[var2++] = (char)(var3 % 10 + 48);
  678.          }
  679.       }
  680.  
  681.       return var2;
  682.    }
  683.  
  684.    public void appendTo(Appendable var1) {
  685.       char[] var2 = (char[])perThreadBuffer.get();
  686.       int var3 = this.getChars(var2);
  687.       if (var1 instanceof StringBuilder) {
  688.          ((StringBuilder)var1).append(var2, 0, var3);
  689.       } else if (var1 instanceof StringBuffer) {
  690.          ((StringBuffer)var1).append(var2, 0, var3);
  691.       } else {
  692.          assert false;
  693.       }
  694.  
  695.    }
  696.  
  697.    public static FloatingDecimal readJavaFormatString(String var0) throws NumberFormatException {
  698.       boolean var1 = false;
  699.       boolean var2 = false;
  700.  
  701.       try {
  702.          var0 = var0.trim();
  703.          int var5 = var0.length();
  704.          if (var5 == 0) {
  705.             throw new NumberFormatException("empty String");
  706.          }
  707.  
  708.          int var6 = 0;
  709.          switch (var0.charAt(var6)) {
  710.             case '-':
  711.                var1 = true;
  712.             case '+':
  713.                ++var6;
  714.                var2 = true;
  715.          }
  716.  
  717.          char var4 = var0.charAt(var6);
  718.          if (var4 != 'N' && var4 != 'I') {
  719.             if (var4 == '0' && var5 > var6 + 1) {
  720.                char var23 = var0.charAt(var6 + 1);
  721.                if (var23 == 'x' || var23 == 'X') {
  722.                   return parseHexString(var0);
  723.                }
  724.             }
  725.  
  726.             char[] var24 = new char[var5];
  727.             int var26 = 0;
  728.             boolean var27 = false;
  729.             int var10 = 0;
  730.             int var11 = 0;
  731.  
  732.             int var12;
  733.             label181:
  734.             for(var12 = 0; var6 < var5; ++var6) {
  735.                switch (var4 = var0.charAt(var6)) {
  736.                   case '.':
  737.                      if (var27) {
  738.                         throw new NumberFormatException("multiple points");
  739.                      }
  740.  
  741.                      var10 = var6;
  742.                      if (var2) {
  743.                         var10 = var6 - 1;
  744.                      }
  745.  
  746.                      var27 = true;
  747.                      continue;
  748.                   case '/':
  749.                   default:
  750.                      break label181;
  751.                   case '0':
  752.                      if (var26 > 0) {
  753.                         ++var12;
  754.                      } else {
  755.                         ++var11;
  756.                      }
  757.                      continue;
  758.                   case '1':
  759.                   case '2':
  760.                   case '3':
  761.                   case '4':
  762.                   case '5':
  763.                   case '6':
  764.                   case '7':
  765.                   case '8':
  766.                   case '9':
  767.                }
  768.  
  769.                while(var12 > 0) {
  770.                   var24[var26++] = '0';
  771.                   --var12;
  772.                }
  773.  
  774.                var24[var26++] = var4;
  775.             }
  776.  
  777.             if (var26 == 0) {
  778.                var24 = zero;
  779.                var26 = 1;
  780.                if (var11 == 0) {
  781.                   throw new NumberFormatException("For input string: \"" + var0 + "\"");
  782.                }
  783.             }
  784.  
  785.             int var3;
  786.             if (var27) {
  787.                var3 = var10 - var11;
  788.             } else {
  789.                var3 = var26 + var12;
  790.             }
  791.  
  792.             if (var6 < var5 && ((var4 = var0.charAt(var6)) == 'e' || var4 == 'E')) {
  793.                byte var13 = 1;
  794.                int var14 = 0;
  795.                int var15 = 214748364;
  796.                boolean var16 = false;
  797.                ++var6;
  798.                int var17;
  799.                switch (var0.charAt(var6)) {
  800.                   case '-':
  801.                      var13 = -1;
  802.                   case '+':
  803.                      ++var6;
  804.                   default:
  805.                      var17 = var6;
  806.                }
  807.  
  808.                label153:
  809.                while(var6 < var5) {
  810.                   if (var14 >= var15) {
  811.                      var16 = true;
  812.                   }
  813.  
  814.                   switch (var4 = var0.charAt(var6++)) {
  815.                      case '0':
  816.                      case '1':
  817.                      case '2':
  818.                      case '3':
  819.                      case '4':
  820.                      case '5':
  821.                      case '6':
  822.                      case '7':
  823.                      case '8':
  824.                      case '9':
  825.                         var14 = var14 * 10 + (var4 - 48);
  826.                         break;
  827.                      default:
  828.                         --var6;
  829.                         break label153;
  830.                   }
  831.                }
  832.  
  833.                int var18 = 324 + var26 + var12;
  834.                if (!var16 && var14 <= var18) {
  835.                   var3 += var13 * var14;
  836.                } else {
  837.                   var3 = var13 * var18;
  838.                }
  839.  
  840.                if (var6 == var17) {
  841.                   throw new NumberFormatException("For input string: \"" + var0 + "\"");
  842.                }
  843.             }
  844.  
  845.             if (var6 >= var5 || var6 == var5 - 1 && (var0.charAt(var6) == 'f' || var0.charAt(var6) == 'F' || var0.charAt(var6) == 'd' || var0.charAt(var6) == 'D')) {
  846.                return new FloatingDecimal(var1, var3, var24, var26, false);
  847.             }
  848.          } else {
  849.             boolean var7 = false;
  850.             Object var8 = null;
  851.             char[] var25;
  852.             if (var4 == 'N') {
  853.                var25 = notANumber;
  854.                var7 = true;
  855.             } else {
  856.                var25 = infinity;
  857.             }
  858.  
  859.             int var9;
  860.             for(var9 = 0; var6 < var5 && var9 < var25.length; ++var9) {
  861.                if (var0.charAt(var6) != var25[var9]) {
  862.                   throw new NumberFormatException("For input string: \"" + var0 + "\"");
  863.                }
  864.  
  865.                ++var6;
  866.             }
  867.  
  868.             if (var9 == var25.length && var6 == var5) {
  869.                return var7 ? new FloatingDecimal(Double.NaN) : new FloatingDecimal(var1 ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY);
  870.             }
  871.          }
  872.       } catch (StringIndexOutOfBoundsException var19) {
  873.       }
  874.  
  875.       throw new NumberFormatException("For input string: \"" + var0 + "\"");
  876.    }
  877.  
  878.    public double doubleValue() {
  879.       int var1 = Math.min(this.nDigits, 16);
  880.       if (this.digits != infinity && this.digits != notANumber) {
  881.          if (this.mustSetRoundDir) {
  882.             this.roundDir = 0;
  883.          }
  884.  
  885.          int var10 = this.digits[0] - 48;
  886.          int var11 = Math.min(var1, 9);
  887.  
  888.          for(int var12 = 1; var12 < var11; ++var12) {
  889.             var10 = var10 * 10 + this.digits[var12] - 48;
  890.          }
  891.  
  892.          long var2 = (long)var10;
  893.  
  894.          for(int var32 = var11; var32 < var1; ++var32) {
  895.             var2 = var2 * 10L + (long)(this.digits[var32] - 48);
  896.          }
  897.  
  898.          double var4 = (double)var2;
  899.          int var33 = this.decExponent - var1;
  900.          if (this.nDigits <= 15) {
  901.             if (var33 == 0 || var4 == (double)0.0F) {
  902.                return this.isNegative ? -var4 : var4;
  903.             }
  904.  
  905.             if (var33 >= 0) {
  906.                if (var33 <= maxSmallTen) {
  907.                   double var28 = var4 * small10pow[var33];
  908.                   if (this.mustSetRoundDir) {
  909.                      double var30 = var28 / small10pow[var33];
  910.                      this.roundDir = var30 == var4 ? 0 : (var30 < var4 ? 1 : -1);
  911.                   }
  912.  
  913.                   return this.isNegative ? -var28 : var28;
  914.                }
  915.  
  916.                int var13 = 15 - var1;
  917.                if (var33 <= maxSmallTen + var13) {
  918.                   var4 *= small10pow[var13];
  919.                   double var6 = var4 * small10pow[var33 - var13];
  920.                   if (this.mustSetRoundDir) {
  921.                      double var8 = var6 / small10pow[var33 - var13];
  922.                      this.roundDir = var8 == var4 ? 0 : (var8 < var4 ? 1 : -1);
  923.                   }
  924.  
  925.                   return this.isNegative ? -var6 : var6;
  926.                }
  927.             } else if (var33 >= -maxSmallTen) {
  928.                double var29 = var4 / small10pow[-var33];
  929.                double var31 = var29 * small10pow[-var33];
  930.                if (this.mustSetRoundDir) {
  931.                   this.roundDir = var31 == var4 ? 0 : (var31 < var4 ? 1 : -1);
  932.                }
  933.  
  934.                return this.isNegative ? -var29 : var29;
  935.             }
  936.          }
  937.  
  938.          if (var33 > 0) {
  939.             if (this.decExponent > 309) {
  940.                return this.isNegative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  941.             }
  942.  
  943.             if ((var33 & 15) != 0) {
  944.                var4 *= small10pow[var33 & 15];
  945.             }
  946.  
  947.             if ((var33 = var33 >> 4) != 0) {
  948.                int var38;
  949.                for(var38 = 0; var33 > 1; var33 >>= 1) {
  950.                   if ((var33 & 1) != 0) {
  951.                      var4 *= big10pow[var38];
  952.                   }
  953.  
  954.                   ++var38;
  955.                }
  956.  
  957.                double var14 = var4 * big10pow[var38];
  958.                if (Double.isInfinite(var14)) {
  959.                   var14 = var4 / (double)2.0F;
  960.                   var14 *= big10pow[var38];
  961.                   if (Double.isInfinite(var14)) {
  962.                      return this.isNegative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  963.                   }
  964.  
  965.                   var14 = Double.MAX_VALUE;
  966.                }
  967.  
  968.                var4 = var14;
  969.             }
  970.          } else if (var33 < 0) {
  971.             var33 = -var33;
  972.             if (this.decExponent < -325) {
  973.                return this.isNegative ? (double)-0.0F : (double)0.0F;
  974.             }
  975.  
  976.             if ((var33 & 15) != 0) {
  977.                var4 /= small10pow[var33 & 15];
  978.             }
  979.  
  980.             if ((var33 = var33 >> 4) != 0) {
  981.                int var39;
  982.                for(var39 = 0; var33 > 1; var33 >>= 1) {
  983.                   if ((var33 & 1) != 0) {
  984.                      var4 *= tiny10pow[var39];
  985.                   }
  986.  
  987.                   ++var39;
  988.                }
  989.  
  990.                double var43 = var4 * tiny10pow[var39];
  991.                if (var43 == (double)0.0F) {
  992.                   var43 = var4 * (double)2.0F;
  993.                   var43 *= tiny10pow[var39];
  994.                   if (var43 == (double)0.0F) {
  995.                      return this.isNegative ? (double)-0.0F : (double)0.0F;
  996.                   }
  997.  
  998.                   var43 = Double.MIN_VALUE;
  999.                }
  1000.  
  1001.                var4 = var43;
  1002.             }
  1003.          }
  1004.  
  1005.          FDBigInt var40 = new FDBigInt(var2, this.digits, var1, this.nDigits);
  1006.          var33 = this.decExponent - this.nDigits;
  1007.  
  1008.          do {
  1009.             FDBigInt var46 = this.doubleToBigInt(var4);
  1010.             int var15;
  1011.             int var16;
  1012.             int var17;
  1013.             int var18;
  1014.             if (var33 >= 0) {
  1015.                var16 = 0;
  1016.                var15 = 0;
  1017.                var18 = var33;
  1018.                var17 = var33;
  1019.             } else {
  1020.                var15 = var16 = -var33;
  1021.                var18 = 0;
  1022.                var17 = 0;
  1023.             }
  1024.  
  1025.             if (this.bigIntExp >= 0) {
  1026.                var15 += this.bigIntExp;
  1027.             } else {
  1028.                var17 -= this.bigIntExp;
  1029.             }
  1030.  
  1031.             int var20;
  1032.             if (this.bigIntExp + this.bigIntNBits <= -1022) {
  1033.                var20 = this.bigIntExp + 1023 + 52;
  1034.             } else {
  1035.                var20 = 54 - this.bigIntNBits;
  1036.             }
  1037.  
  1038.             int var48 = var15 + var20;
  1039.             var17 += var20;
  1040.             int var21 = Math.min(var48, Math.min(var17, var15));
  1041.             int var49 = var48 - var21;
  1042.             var17 -= var21;
  1043.             int var52 = var15 - var21;
  1044.             var46 = multPow52(var46, var16, var49);
  1045.             FDBigInt var22 = multPow52(new FDBigInt(var40), var18, var17);
  1046.             FDBigInt var23;
  1047.             int var24;
  1048.             boolean var25;
  1049.             if ((var24 = var46.cmp(var22)) > 0) {
  1050.                var25 = true;
  1051.                var23 = var46.sub(var22);
  1052.                if (this.bigIntNBits == 1 && this.bigIntExp > -1023) {
  1053.                   --var52;
  1054.                   if (var52 < 0) {
  1055.                      var52 = 0;
  1056.                      var23.lshiftMe(1);
  1057.                   }
  1058.                }
  1059.             } else {
  1060.                if (var24 >= 0) {
  1061.                   break;
  1062.                }
  1063.  
  1064.                var25 = false;
  1065.                var23 = var22.sub(var46);
  1066.             }
  1067.  
  1068.             FDBigInt var26 = constructPow52(var16, var52);
  1069.             if ((var24 = var23.cmp(var26)) < 0) {
  1070.                if (this.mustSetRoundDir) {
  1071.                   this.roundDir = var25 ? -1 : 1;
  1072.                }
  1073.                break;
  1074.             }
  1075.  
  1076.             if (var24 == 0) {
  1077.                var4 += (double)0.5F * ulp(var4, var25);
  1078.                if (this.mustSetRoundDir) {
  1079.                   this.roundDir = var25 ? -1 : 1;
  1080.                }
  1081.                break;
  1082.             }
  1083.  
  1084.             var4 += ulp(var4, var25);
  1085.          } while(var4 != (double)0.0F && var4 != Double.POSITIVE_INFINITY);
  1086.  
  1087.          return this.isNegative ? -var4 : var4;
  1088.       } else if (this.digits == notANumber) {
  1089.          return Double.NaN;
  1090.       } else {
  1091.          return this.isNegative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
  1092.       }
  1093.    }
  1094.  
  1095.    public float floatValue() {
  1096.       int var1 = Math.min(this.nDigits, 8);
  1097.       if (this.digits != infinity && this.digits != notANumber) {
  1098.          int var2 = this.digits[0] - 48;
  1099.  
  1100.          for(int var4 = 1; var4 < var1; ++var4) {
  1101.             var2 = var2 * 10 + this.digits[var4] - 48;
  1102.          }
  1103.  
  1104.          float var3 = (float)var2;
  1105.          int var14 = this.decExponent - var1;
  1106.          if (this.nDigits <= 7) {
  1107.             if (var14 == 0 || var3 == 0.0F) {
  1108.                return this.isNegative ? -var3 : var3;
  1109.             }
  1110.  
  1111.             if (var14 >= 0) {
  1112.                if (var14 <= singleMaxSmallTen) {
  1113.                   var3 *= singleSmall10pow[var14];
  1114.                   return this.isNegative ? -var3 : var3;
  1115.                }
  1116.  
  1117.                int var5 = 7 - var1;
  1118.                if (var14 <= singleMaxSmallTen + var5) {
  1119.                   var3 *= singleSmall10pow[var5];
  1120.                   var3 *= singleSmall10pow[var14 - var5];
  1121.                   return this.isNegative ? -var3 : var3;
  1122.                }
  1123.             } else if (var14 >= -singleMaxSmallTen) {
  1124.                var3 /= singleSmall10pow[-var14];
  1125.                return this.isNegative ? -var3 : var3;
  1126.             }
  1127.          } else if (this.decExponent >= this.nDigits && this.nDigits + this.decExponent <= 15) {
  1128.             long var17 = (long)var2;
  1129.  
  1130.             for(int var7 = var1; var7 < this.nDigits; ++var7) {
  1131.                var17 = var17 * 10L + (long)(this.digits[var7] - 48);
  1132.             }
  1133.  
  1134.             double var18 = (double)var17;
  1135.             var14 = this.decExponent - this.nDigits;
  1136.             var18 *= small10pow[var14];
  1137.             var3 = (float)var18;
  1138.             return this.isNegative ? -var3 : var3;
  1139.          }
  1140.  
  1141.          if (this.decExponent > 39) {
  1142.             return this.isNegative ? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
  1143.          } else if (this.decExponent < -46) {
  1144.             return this.isNegative ? -0.0F : 0.0F;
  1145.          } else {
  1146.             this.mustSetRoundDir = !this.fromHex;
  1147.             double var16 = this.doubleValue();
  1148.             return this.stickyRound(var16);
  1149.          }
  1150.       } else if (this.digits == notANumber) {
  1151.          return Float.NaN;
  1152.       } else {
  1153.          return this.isNegative ? Float.NEGATIVE_INFINITY : Float.POSITIVE_INFINITY;
  1154.       }
  1155.    }
  1156.  
  1157.    static FloatingDecimal parseHexString(String var0) {
  1158.       Matcher var1 = hexFloatPattern.matcher(var0);
  1159.       boolean var2 = var1.matches();
  1160.       if (!var2) {
  1161.          throw new NumberFormatException("For input string: \"" + var0 + "\"");
  1162.       } else {
  1163.          String var3 = var1.group(1);
  1164.          double var4 = var3 != null && !var3.equals("+") ? (double)-1.0F : (double)1.0F;
  1165.          Object var6 = null;
  1166.          int var7 = 0;
  1167.          int var8 = 0;
  1168.          int var9 = 0;
  1169.          int var10 = 0;
  1170.          String var11;
  1171.          String var30;
  1172.          if ((var11 = var1.group(4)) != null) {
  1173.             var30 = stripLeadingZeros(var11);
  1174.             var9 = var30.length();
  1175.          } else {
  1176.             String var12 = stripLeadingZeros(var1.group(6));
  1177.             var9 = var12.length();
  1178.             String var13 = var1.group(7);
  1179.             var10 = var13.length();
  1180.             var30 = (var12 == null ? "" : var12) + var13;
  1181.          }
  1182.  
  1183.          var30 = stripLeadingZeros(var30);
  1184.          var7 = var30.length();
  1185.          if (var9 >= 1) {
  1186.             var8 = 4 * (var9 - 1);
  1187.          } else {
  1188.             var8 = -4 * (var10 - var7 + 1);
  1189.          }
  1190.  
  1191.          if (var7 == 0) {
  1192.             return new FloatingDecimal(var4 * (double)0.0F);
  1193.          } else {
  1194.             String var35 = var1.group(8);
  1195.             var10 = var35 == null || var35.equals("+");
  1196.  
  1197.             try {
  1198.                var37 = (long)Integer.parseInt(var1.group(9));
  1199.             } catch (NumberFormatException var29) {
  1200.                return new FloatingDecimal(var4 * (var10 ? Double.POSITIVE_INFINITY : (double)0.0F));
  1201.             }
  1202.  
  1203.             long var38 = (var10 ? 1L : -1L) * var37;
  1204.             long var15 = var38 + (long)var8;
  1205.             boolean var17 = false;
  1206.             boolean var18 = false;
  1207.             boolean var19 = false;
  1208.             int var20 = 0;
  1209.             long var21 = 0L;
  1210.             long var23 = (long)getHexDigit(var30, 0);
  1211.             if (var23 == 1L) {
  1212.                var21 |= var23 << 52;
  1213.                var20 = 48;
  1214.             } else if (var23 <= 3L) {
  1215.                var21 |= var23 << 51;
  1216.                var20 = 47;
  1217.                ++var15;
  1218.             } else if (var23 <= 7L) {
  1219.                var21 |= var23 << 50;
  1220.                var20 = 46;
  1221.                var15 += 2L;
  1222.             } else {
  1223.                if (var23 > 15L) {
  1224.                   throw new AssertionError("Result from digit conversion too large!");
  1225.                }
  1226.  
  1227.                var21 |= var23 << 49;
  1228.                var20 = 45;
  1229.                var15 += 3L;
  1230.             }
  1231.  
  1232.             int var25 = 0;
  1233.  
  1234.             for(var25 = 1; var25 < var7 && var20 >= 0; ++var25) {
  1235.                long var26 = (long)getHexDigit(var30, var25);
  1236.                var21 |= var26 << var20;
  1237.                var20 -= 4;
  1238.             }
  1239.  
  1240.             if (var25 < var7) {
  1241.                long var46 = (long)getHexDigit(var30, var25);
  1242.                switch (var20) {
  1243.                   case -4:
  1244.                      var17 = (var46 & 8L) != 0L;
  1245.                      var18 = (var46 & 7L) != 0L;
  1246.                      break;
  1247.                   case -3:
  1248.                      var21 |= (var46 & 8L) >> 3;
  1249.                      var17 = (var46 & 4L) != 0L;
  1250.                      var18 = (var46 & 3L) != 0L;
  1251.                      break;
  1252.                   case -2:
  1253.                      var21 |= (var46 & 12L) >> 2;
  1254.                      var17 = (var46 & 2L) != 0L;
  1255.                      var18 = (var46 & 1L) != 0L;
  1256.                      break;
  1257.                   case -1:
  1258.                      var21 |= (var46 & 14L) >> 1;
  1259.                      var17 = (var46 & 1L) != 0L;
  1260.                      break;
  1261.                   default:
  1262.                      throw new AssertionError("Unexpected shift distance remainder.");
  1263.                }
  1264.  
  1265.                ++var25;
  1266.  
  1267.                while(var25 < var7 && !var18) {
  1268.                   var46 = (long)getHexDigit(var30, var25);
  1269.                   var18 = var18 || var46 != 0L;
  1270.                   ++var25;
  1271.                }
  1272.             }
  1273.  
  1274.             if (var15 > 1023L) {
  1275.                return new FloatingDecimal(var4 * Double.POSITIVE_INFINITY);
  1276.             } else {
  1277.                if (var15 <= 1023L && var15 >= -1022L) {
  1278.                   var21 = var15 + 1023L << 52 & 9218868437227405312L | 4503599627370495L & var21;
  1279.                } else {
  1280.                   if (var15 < -1075L) {
  1281.                      return new FloatingDecimal(var4 * (double)0.0F);
  1282.                   }
  1283.  
  1284.                   var18 = var18 || var17;
  1285.                   var17 = false;
  1286.                   int var48 = 53 - ((int)var15 - -1074 + 1);
  1287.  
  1288.                   assert var48 >= 1 && var48 <= 53;
  1289.  
  1290.                   var17 = (var21 & 1L << var48 - 1) != 0L;
  1291.                   if (var48 > 1) {
  1292.                      long var27 = ~(-1L << var48 - 1);
  1293.                      var18 = var18 || (var21 & var27) != 0L;
  1294.                   }
  1295.  
  1296.                   var21 >>= var48;
  1297.                   var21 = 0L | 4503599627370495L & var21;
  1298.                }
  1299.  
  1300.                boolean var49 = false;
  1301.                boolean var51 = (var21 & 1L) == 0L;
  1302.                if (var51 && var17 && var18 || !var51 && var17) {
  1303.                   var49 = true;
  1304.                   ++var21;
  1305.                }
  1306.  
  1307.                FloatingDecimal var28 = new FloatingDecimal(FpUtils.rawCopySign(Double.longBitsToDouble(var21), var4));
  1308.                if (var15 >= -150L && var15 <= 127L && (var21 & 268435455L) == 0L && (var17 || var18)) {
  1309.                   if (var51) {
  1310.                      if (var17 ^ var18) {
  1311.                         var28.roundDir = 1;
  1312.                      }
  1313.                   } else if (var17) {
  1314.                      var28.roundDir = -1;
  1315.                   }
  1316.                }
  1317.  
  1318.                var28.fromHex = true;
  1319.                return var28;
  1320.             }
  1321.          }
  1322.       }
  1323.    }
  1324.  
  1325.    static String stripLeadingZeros(String var0) {
  1326.       return var0.replaceFirst("^0+", "");
  1327.    }
  1328.  
  1329.    static int getHexDigit(String var0, int var1) {
  1330.       int var2 = Character.digit(var0.charAt(var1), 16);
  1331.       if (var2 > -1 && var2 < 16) {
  1332.          return var2;
  1333.       } else {
  1334.          throw new AssertionError("Unexpected failure of digit conversion of " + var0.charAt(var1));
  1335.       }
  1336.    }
  1337.  
  1338.    static {
  1339.       maxSmallTen = small10pow.length - 1;
  1340.       singleMaxSmallTen = singleSmall10pow.length - 1;
  1341.       small5pow = new int[]{1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125};
  1342.       long5pow = new long[]{1L, 5L, 25L, 125L, 625L, 3125L, 15625L, 78125L, 390625L, 1953125L, 9765625L, 48828125L, 244140625L, 1220703125L, 6103515625L, 30517578125L, 152587890625L, 762939453125L, 3814697265625L, 19073486328125L, 95367431640625L, 476837158203125L, 2384185791015625L, 11920928955078125L, 59604644775390625L, 298023223876953125L, 1490116119384765625L};
  1343.       n5bits = new int[]{0, 3, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28, 31, 33, 35, 38, 40, 42, 45, 47, 49, 52, 54, 56, 59, 61};
  1344.       infinity = new char[]{'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'};
  1345.       notANumber = new char[]{'N', 'a', 'N'};
  1346.       zero = new char[]{'0', '0', '0', '0', '0', '0', '0', '0'};
  1347.       hexFloatPattern = Pattern.compile("([-+])?0[xX](((\\p{XDigit}+)\\.?)|((\\p{XDigit}*)\\.(\\p{XDigit}+)))[pP]([-+])?(\\p{Digit}+)[fFdD]?");
  1348.    }
  1349. }
  1350.